"""
__L2_SF2SF_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Wed Dec 12 18:21:49 2012
______________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Station_S import *
from Female_S import *
from MatchModel import *
from ApplyModel import *
from Station_T import *
from Female_T import *
from match_contains import *
from apply_contains import *
from backward_link import *
from indirectLink_S import *
from directLink_T import *
from graph_backward_link import *
from graph_ApplyModel import *
from graph_directLink_T import *
from graph_MatchModel import *
from graph_apply_contains import *
from graph_Station_T import *
from graph_Station_S import *
from graph_match_contains import *
from graph_Female_S import *
from graph_Female_T import *
from graph_indirectLink_S import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def L2_SF2SF_MDL(self, rootNode, SimpleDSLTransMMRootNode=None):

    # --- Generating attributes code for ASG SimpleDSLTransMM ---
    if( SimpleDSLTransMMRootNode ): 
        # author
        SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        SimpleDSLTransMMRootNode.description.setValue('\n')
        SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        SimpleDSLTransMMRootNode.name.setValue('SF2SF')
    # --- ASG attributes over ---


    self.obj44=Station_S(self)
    self.obj44.isGraphObjectVisual = True

    if(hasattr(self.obj44, '_setHierarchicalLink')):
      self.obj44._setHierarchicalLink(False)

    # name
    self.obj44.name.setValue('s')

    self.obj44.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(620.0,260.0,self.obj44)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj44.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj44)
    self.globalAndLocalPostcondition(self.obj44, rootNode)
    self.obj44.postAction( rootNode.CREATE )

    self.obj58=Female_S(self)
    self.obj58.isGraphObjectVisual = True

    if(hasattr(self.obj58, '_setHierarchicalLink')):
      self.obj58._setHierarchicalLink(False)

    # name
    self.obj58.name.setValue('f')

    self.obj58.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(860.0,260.0,self.obj58)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj58.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj58)
    self.globalAndLocalPostcondition(self.obj58, rootNode)
    self.obj58.postAction( rootNode.CREATE )

    self.obj46=MatchModel(self)
    self.obj46.isGraphObjectVisual = True

    if(hasattr(self.obj46, '_setHierarchicalLink')):
      self.obj46._setHierarchicalLink(False)

    self.obj46.graphClass_= graph_MatchModel
    if self.genGraphics:
       new_obj = graph_MatchModel(360.0,200.0,self.obj46)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj46.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj46)
    self.globalAndLocalPostcondition(self.obj46, rootNode)
    self.obj46.postAction( rootNode.CREATE )

    self.obj47=ApplyModel(self)
    self.obj47.isGraphObjectVisual = True

    if(hasattr(self.obj47, '_setHierarchicalLink')):
      self.obj47._setHierarchicalLink(False)

    self.obj47.graphClass_= graph_ApplyModel
    if self.genGraphics:
       new_obj = graph_ApplyModel(360.0,440.0,self.obj47)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj47.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj47)
    self.globalAndLocalPostcondition(self.obj47, rootNode)
    self.obj47.postAction( rootNode.CREATE )

    self.obj48=Station_T(self)
    self.obj48.isGraphObjectVisual = True

    if(hasattr(self.obj48, '_setHierarchicalLink')):
      self.obj48._setHierarchicalLink(False)

    # name
    self.obj48.name.setValue('s')

    self.obj48.graphClass_= graph_Station_T
    if self.genGraphics:
       new_obj = graph_Station_T(620.0,520.0,self.obj48)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj48.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj48)
    self.globalAndLocalPostcondition(self.obj48, rootNode)
    self.obj48.postAction( rootNode.CREATE )

    self.obj59=Female_T(self)
    self.obj59.isGraphObjectVisual = True

    if(hasattr(self.obj59, '_setHierarchicalLink')):
      self.obj59._setHierarchicalLink(False)

    # name
    self.obj59.name.setValue('f')

    self.obj59.graphClass_= graph_Female_T
    if self.genGraphics:
       new_obj = graph_Female_T(860.0,520.0,self.obj59)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj59.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj59)
    self.globalAndLocalPostcondition(self.obj59, rootNode)
    self.obj59.postAction( rootNode.CREATE )

    self.obj50=match_contains(self)
    self.obj50.isGraphObjectVisual = True

    if(hasattr(self.obj50, '_setHierarchicalLink')):
      self.obj50._setHierarchicalLink(False)

    self.obj50.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(551.0,271.0,self.obj50)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj50.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj50)
    self.globalAndLocalPostcondition(self.obj50, rootNode)
    self.obj50.postAction( rootNode.CREATE )

    self.obj67=match_contains(self)
    self.obj67.isGraphObjectVisual = True

    if(hasattr(self.obj67, '_setHierarchicalLink')):
      self.obj67._setHierarchicalLink(False)

    self.obj67.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(671.0,271.0,self.obj67)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj67.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj67)
    self.globalAndLocalPostcondition(self.obj67, rootNode)
    self.obj67.postAction( rootNode.CREATE )

    self.obj52=apply_contains(self)
    self.obj52.isGraphObjectVisual = True

    if(hasattr(self.obj52, '_setHierarchicalLink')):
      self.obj52._setHierarchicalLink(False)

    self.obj52.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(553.5,521.0,self.obj52)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj52.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj52)
    self.globalAndLocalPostcondition(self.obj52, rootNode)
    self.obj52.postAction( rootNode.CREATE )

    self.obj68=apply_contains(self)
    self.obj68.isGraphObjectVisual = True

    if(hasattr(self.obj68, '_setHierarchicalLink')):
      self.obj68._setHierarchicalLink(False)

    self.obj68.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(673.5,521.0,self.obj68)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj68.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj68)
    self.globalAndLocalPostcondition(self.obj68, rootNode)
    self.obj68.postAction( rootNode.CREATE )

    self.obj54=backward_link(self)
    self.obj54.isGraphObjectVisual = True

    if(hasattr(self.obj54, '_setHierarchicalLink')):
      self.obj54._setHierarchicalLink(False)

    self.obj54.graphClass_= graph_backward_link
    if self.genGraphics:
       new_obj = graph_backward_link(681.0,431.0,self.obj54)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj54.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj54)
    self.globalAndLocalPostcondition(self.obj54, rootNode)
    self.obj54.postAction( rootNode.CREATE )

    self.obj64=backward_link(self)
    self.obj64.isGraphObjectVisual = True

    if(hasattr(self.obj64, '_setHierarchicalLink')):
      self.obj64._setHierarchicalLink(False)

    self.obj64.graphClass_= graph_backward_link
    if self.genGraphics:
       new_obj = graph_backward_link(921.0,431.0,self.obj64)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj64.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj64)
    self.globalAndLocalPostcondition(self.obj64, rootNode)
    self.obj64.postAction( rootNode.CREATE )

    self.obj65=indirectLink_S(self)
    self.obj65.isGraphObjectVisual = True

    if(hasattr(self.obj65, '_setHierarchicalLink')):
      self.obj65._setHierarchicalLink(False)

    self.obj65.graphClass_= graph_indirectLink_S
    if self.genGraphics:
       new_obj = graph_indirectLink_S(801.0,301.0,self.obj65)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("indirectLink_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj65.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj65)
    self.globalAndLocalPostcondition(self.obj65, rootNode)
    self.obj65.postAction( rootNode.CREATE )

    self.obj66=directLink_T(self)
    self.obj66.isGraphObjectVisual = True

    if(hasattr(self.obj66, '_setHierarchicalLink')):
      self.obj66._setHierarchicalLink(False)

    self.obj66.graphClass_= graph_directLink_T
    if self.genGraphics:
       new_obj = graph_directLink_T(801.0,561.0,self.obj66)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("directLink_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj66.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj66)
    self.globalAndLocalPostcondition(self.obj66, rootNode)
    self.obj66.postAction( rootNode.CREATE )

    # Connections for obj44 (graphObject_: Obj14) named s
    self.drawConnections(
(self.obj44,self.obj65,[681.0, 301.0, 801.0, 301.0],"true", 2) )
    # Connections for obj58 (graphObject_: Obj28) named f
    self.drawConnections(
 )
    # Connections for obj46 (graphObject_: Obj16) of type MatchModel
    self.drawConnections(
(self.obj46,self.obj50,[421.0, 241.0, 551.0, 271.0],"true", 2),
(self.obj46,self.obj67,[421.0, 241.0, 671.0, 271.0],"true", 2) )
    # Connections for obj47 (graphObject_: Obj17) of type ApplyModel
    self.drawConnections(
(self.obj47,self.obj52,[426.0, 481.0, 553.5, 521.0],"true", 2),
(self.obj47,self.obj68,[426.0, 481.0, 673.5, 521.0],"true", 2) )
    # Connections for obj48 (graphObject_: Obj18) named s
    self.drawConnections(
(self.obj48,self.obj54,[681.0, 561.0, 681.0, 431.0],"true", 2),
(self.obj48,self.obj66,[681.0, 561.0, 801.0, 561.0],"true", 2) )
    # Connections for obj59 (graphObject_: Obj29) named f
    self.drawConnections(
(self.obj59,self.obj64,[921.0, 561.0, 921.0, 431.0],"true", 2) )
    # Connections for obj50 (graphObject_: Obj20) of type match_contains
    self.drawConnections(
(self.obj50,self.obj44,[551.0, 271.0, 681.0, 301.0],"true", 2) )
    # Connections for obj67 (graphObject_: Obj33) of type match_contains
    self.drawConnections(
(self.obj67,self.obj58,[671.0, 271.0, 921.0, 301.0],"true", 2) )
    # Connections for obj52 (graphObject_: Obj22) of type apply_contains
    self.drawConnections(
(self.obj52,self.obj48,[553.5, 521.0, 681.0, 561.0],"true", 2) )
    # Connections for obj68 (graphObject_: Obj34) of type apply_contains
    self.drawConnections(
(self.obj68,self.obj59,[673.5, 521.0, 921.0, 561.0],"true", 2) )
    # Connections for obj54 (graphObject_: Obj24) of type backward_link
    self.drawConnections(
(self.obj54,self.obj44,[681.0, 431.0, 681.0, 301.0],"true", 2) )
    # Connections for obj64 (graphObject_: Obj30) of type backward_link
    self.drawConnections(
(self.obj64,self.obj58,[921.0, 431.0, 921.0, 301.0],"true", 2) )
    # Connections for obj65 (graphObject_: Obj31) of type indirectLink_S
    self.drawConnections(
(self.obj65,self.obj58,[801.0, 301.0, 921.0, 301.0],"true", 2) )
    # Connections for obj66 (graphObject_: Obj32) of type directLink_T
    self.drawConnections(
(self.obj66,self.obj59,[801.0, 561.0, 921.0, 561.0],"true", 2) )

newfunction = L2_SF2SF_MDL

loadedMMName = 'SimpleDSLTransMM_META'

atom3version = '0.3'
